host_attr_ro = ['software_version',
'resident_VMs',
'host_CPUs',
+ 'cpu_configuration',
'metrics',
'capabilities',
'supported_bootloaders',
'API_version_vendor_implementation']
host_attr_rw = ['name_label',
+ 'sched_policy',
'name_description',
'other_config']
return xen_api_success(XendNode.instance().get_capabilities())
def host_get_supported_bootloaders(self, session, host_ref):
return xen_api_success(['pygrub'])
-
+ def host_get_sched_policy(self, _, host_ref):
+ return xen_api_success(XendNode.instance().get_vcpus_policy())
+ def host_set_sched_policy(self, _, host_ref, policy):
+ return xen_api_todo()
+ def host_get_cpu_configuration(self, _, host_ref):
+ return xen_api_success(XendNode.instance().get_cpu_configuration())
+
# object methods
def host_disable(self, session, host_ref):
XendDomain.instance().set_allow_new_domains(False)
'other_config': node.other_config,
'resident_VMs': dom.get_domain_refs(),
'host_CPUs': node.get_host_cpu_refs(),
+ 'cpu_configuration': node.get_cpu_configuration(),
'metrics': node.host_metrics_uuid,
'capabilities': node.get_capabilities(),
- 'supported_bootloaders': 'pygrub'}
+ 'supported_bootloaders': 'pygrub',
+ 'sched_policy': node.get_vcpus_policy()}
return xen_api_success(record)
# class methods
'modelname',
'stepping',
'flags',
- 'utilisation']
+ 'utilisation',
+ 'features']
# attributes
def _host_cpu_get(self, ref, field):
def host_cpu_get_host(self, _, ref):
return xen_api_success(XendNode.instance().uuid)
+ def host_cpu_get_features(self, _, ref):
+ return self._host_cpu_get(ref, 'features')
def host_cpu_get_number(self, _, ref):
return self._host_cpu_get(ref, 'number')
def host_cpu_get_vendor(self, _, ref):
'auto_power_on',
'memory_dynamic_max',
'memory_dynamic_min',
- 'VCPUs_policy',
'VCPUs_params',
'actions_after_shutdown',
'actions_after_reboot',
'memory_dynamic_max',
'memory_dynamic_min',
'memory_static_min',
- 'VCPUs_policy',
'VCPUs_params',
'actions_after_shutdown',
'actions_after_reboot',
def VM_get_memory_dynamic_min(self, session, vm_ref):
dom = XendDomain.instance().get_vm_by_uuid(vm_ref)
- return xen_api_success(dom.get_memory_dynamic_min())
-
- def VM_get_VCPUs_policy(self, session, vm_ref):
- dom = XendDomain.instance().get_vm_by_uuid(vm_ref)
- return xen_api_success(dom.get_vcpus_policy())
+ return xen_api_success(dom.get_memory_dynamic_min())
def VM_get_VCPUs_params(self, session, vm_ref):
dom = XendDomain.instance().get_vm_by_uuid(vm_ref)
dom = XendDomain.instance().get_vm_by_uuid(vm_ref)
return xen_api_todo()
- def VM_set_VCPUs_policy(self, session, vm_ref, policy):
- dom = XendDomain.instance().get_vm_by_uuid(vm_ref)
- return xen_api_todo()
-
def VM_set_VCPUs_params(self, session, vm_ref, value):
return self.VM_set('vcpus_params', session, vm_ref, value)
'memory_static_max': xeninfo.get_memory_static_max(),
'memory_dynamic_min': xeninfo.get_memory_dynamic_min(),
'memory_dynamic_max': xeninfo.get_memory_dynamic_max(),
- 'VCPUs_policy': xeninfo.get_vcpus_policy(),
'VCPUs_params': xeninfo.get_vcpus_params(),
'VCPUs_number': xeninfo.getVCpuCount(),
'actions_after_shutdown': xeninfo.get_on_shutdown(),
return self.info.get('memory_dynamic_max', 0)
def get_memory_dynamic_min(self):
return self.info.get('memory_dynamic_min', 0)
-
- def get_vcpus_policy(self):
- sched_id = xc.sched_id_get()
- if sched_id == xen.lowlevel.xc.XEN_SCHEDULER_SEDF:
- return 'sedf'
- elif sched_id == xen.lowlevel.xc.XEN_SCHEDULER_CREDIT:
- return 'credit'
- else:
- return 'unknown'
def get_vcpus_params(self):
if self.getDomid() is None:
return self.info['vcpus_params']
self.other_config = {}
self.cpus = {}
self.host_metrics_uuid = uuid.createString()
+
+ # put some arbitrary params in other_config as this
+ # is directly exposed via XenAPI
+ self.other_config["xen_pagesize"] = self.xeninfo_dict()["xen_pagesize"]
+ self.other_config["platform_params"] = self.xeninfo_dict()["platform_params"]
# load CPU UUIDs
saved_cpus = self.state_store.load_state('cpu')
def xen_version(self):
info = self.xc.xeninfo()
+
try:
from xen import VERSION
- return {'Xen': '%(xen_major)d.%(xen_minor)d' % info,
+ info = {'Xen': '%(xen_major)d.%(xen_minor)d' % info,
'Xend': VERSION}
except (ImportError, AttributeError):
- return {'Xen': '%(xen_major)d.%(xen_minor)d' % info,
+ info = {'Xen': '%(xen_major)d.%(xen_minor)d' % info,
'Xend': '3.0.3'}
+ # Add xend_config_format
+ info.update(self.xendinfo_dict())
+
+ # Add version info about machine
+ info.update(self.nodeinfo_dict())
+
+ # Add specific xen version info
+ xeninfo_dict = self.xeninfo_dict()
+
+ info.update({
+ "xen_major": xeninfo_dict["xen_major"],
+ "xen_minor": xeninfo_dict["xen_minor"],
+ "xen_extra": xeninfo_dict["xen_extra"],
+ "cc_compiler": xeninfo_dict["cc_compiler"],
+ "cc_compile_by": xeninfo_dict["cc_compile_by"],
+ "cc_compile_domain": xeninfo_dict["cc_compile_domain"],
+ "cc_compile_date": xeninfo_dict["cc_compile_date"],
+ "xen_changeset": xeninfo_dict["xen_changeset"]
+ })
+
+ return info
+
def get_name(self):
return self.name
return 0.0
+ def get_vcpus_policy(self):
+ sched_id = self.xc.sched_id_get()
+ if sched_id == xen.lowlevel.xc.XEN_SCHEDULER_SEDF:
+ return 'sedf'
+ elif sched_id == xen.lowlevel.xc.XEN_SCHEDULER_CREDIT:
+ return 'credit'
+ else:
+ return 'unknown'
+
+ def get_cpu_configuration(self):
+ phys_info = self.physinfo_dict()
+
+ cpu_info = {
+ "nr_nodes": phys_info["nr_nodes"],
+ "sockets_per_node": phys_info["sockets_per_node"],
+ "cores_per_socket": phys_info["cores_per_socket"],
+ "threads_per_core": phys_info["threads_per_core"]
+ }
+
+ return cpu_info
+
#
# Network Functions
#
}
def check_sched_type(sched):
- current = 'unknown'
- for x in server.xend.node.info()[1:]:
- if len(x) > 1 and x[0] == 'xen_scheduler':
- current = x[1]
- break
+ if serverType == SERVER_XEN_API:
+ current = server.xenapi.host.get_sched_policy(server.xenapi.session.get_this_host())
+ else:
+ current = 'unknown'
+ for x in server.xend.node.info()[1:]:
+ if len(x) > 1 and x[0] == 'xen_scheduler':
+ current = x[1]
+ break
if sched != current:
err("Xen is running with the %s scheduler" % current)
sys.exit(1)
arg_check(args, "mem-max", 2)
dom = args[0]
- mem = int_unit(args[1], 'm')
- server.xend.domain.maxmem_set(dom, mem)
+ if serverType == SERVER_XEN_API:
+ mem = int_unit(args[1], 'k') * 1024
+ server.xenapi.VM.set_memory_static_max(get_single_vm(dom), mem)
+ else:
+ mem = int_unit(args[1], 'm')
+ server.xend.domain.maxmem_set(dom, mem)
def xm_mem_set(args):
arg_check(args, "mem-set", 2)
dom = args[0]
- mem_target = int_unit(args[1], 'm')
- server.xend.domain.setMemoryTarget(dom, mem_target)
+ if serverType == SERVER_XEN_API:
+ mem_target = int_unit(args[1], 'k') * 1024
+ server.xenapi.VM.set_memory_dynamic_max(get_single_vm(dom), mem_target)
+ server.xenapi.VM.set_memory_dynamic_min(get_single_vm(dom), mem_target)
+ else:
+ mem_target = int_unit(args[1], 'm')
+ server.xend.domain.setMemoryTarget(dom, mem_target)
def xm_vcpu_set(args):
arg_check(args, "vcpu-set", 2)
-
- server.xend.domain.setVCpuCount(args[0], int(args[1]))
+ dom = args[0]
+ vcpus = int(args[1])
+
+ if serverType == SERVER_XEN_API:
+ server.xenapi.VM.set_vcpus_live(get_single_vm(dom), vcpus)
+ else:
+ server.xend.domain.setVCpuCount(dom, vcpus)
def xm_destroy(args):
arg_check(args, "destroy", 1)
dom = args[0]
+
if serverType == SERVER_XEN_API:
server.xenapi.VM.hard_shutdown(get_single_vm(dom))
else:
arg_check(args, "domname", 1)
name = args[0]
-
- dom = server.xend.domain(name)
- print sxp.child_value(dom, 'name')
+
+ if serverType == SERVER_XEN_API:
+ print server.xenapi.VM.get_domid(get_single_vm(dom))
+ else:
+ dom = server.xend.domain(name)
+ print sxp.child_value(dom, 'name')
def xm_sched_sedf(args):
def ns_to_ms(val):
def xm_info(args):
arg_check(args, "info", 0)
- info = server.xend.node.info()
-
- for x in info[1:]:
- if len(x) < 2:
- print "%-23s: (none)" % x[0]
- else:
- print "%-23s:" % x[0], x[1]
+ if serverType == SERVER_XEN_API:
+
+ # Need to fake out old style xm info as people rely on parsing it
+
+ host_record = server.xenapi.host.get_record(
+ server.xenapi.session.get_this_host())
+
+ host_cpu_records = map(server.xenapi.host_cpu.get_record, host_record["host_CPUs"])
+
+ host_metrics_record = server.xenapi.host_metrics.get_record(host_record["metrics"])
+
+ info = {
+ "host": host_record["name_label"],
+ "release": host_record["software_version"]["release"],
+ "version": host_record["software_version"]["version"],
+ "machine": host_record["software_version"]["machine"],
+ "nr_cpus": len(host_record["host_CPUs"]),
+ "nr_nodes": host_record["cpu_configuration"]["nr_nodes"],
+ "sockets_per_node": host_record["cpu_configuration"]["sockets_per_node"],
+ "cores_per_socket": host_record["cpu_configuration"]["cores_per_socket"],
+ "threads_per_core": host_record["cpu_configuration"]["threads_per_core"],
+ "cpu_mhz": sum([int(host_cpu_record["speed"]) for host_cpu_record in host_cpu_records])
+ / len(host_cpu_records),
+ "hw_caps": host_cpu_records[0]["features"],
+ "total_memory": int(host_metrics_record["memory_total"])/1024/1024,
+ "free_memory": int(host_metrics_record["memory_free"])/1024/1024,
+ "xen_major": host_record["software_version"]["xen_major"],
+ "xen_minor": host_record["software_version"]["xen_minor"],
+ "xen_extra": host_record["software_version"]["xen_extra"],
+ "xen_caps": " ".join(host_record["capabilities"]),
+ "xen_scheduler": host_record["sched_policy"],
+ "xen_pagesize": host_record["other_config"]["xen_pagesize"],
+ "platform_params": host_record["other_config"]["platform_params"],
+ "xen_changeset": host_record["software_version"]["xen_changeset"],
+ "cc_compiler": host_record["software_version"]["cc_compiler"],
+ "cc_compile_by": host_record["software_version"]["cc_compile_by"],
+ "cc_compile_domain": host_record["software_version"]["cc_compile_domain"],
+ "cc_compile_date": host_record["software_version"]["cc_compile_date"],
+ "xend_config_format":host_record["software_version"]["xend_config_format"]
+ }
+
+ sorted = info.items()
+ sorted.sort(lambda (x1,y1), (x2,y2): -cmp(x1,x2))
+
+ for (k, v) in sorted:
+ print "%-23s:" % k, v
+ else:
+ info = server.xend.node.info()
+ for x in info[1:]:
+ if len(x) < 2:
+ print "%-23s: (none)" % x[0]
+ else:
+ print "%-23s:" % x[0], x[1]
def xm_console(args):
arg_check(args, "console", 1, 2)
projects / xen.git / commitdiff